package com.software.Date12_05;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String s = in.nextLine();
        if(s.contains("LANQIAO")){
            System.out.println("YES");
        }else{
            System.out.println("NO");
        }
    }
    public static void main6(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int result = 2024/n;
        if(2024 % n > 0){
            result+=1;
        }
        System.out.println(result);
        System.out.println(Integer.MAX_VALUE);
    }
    public static void main5(String[] args) {
        /**
         * 57, 252, 575, 630, 95, 274, 328, 614, 18, 605, 17, 980, 166, 112, 997, 37, 584, 64, 442, 495,
         *
         * 821, 459, 453, 597, 187, 734, 827, 950, 679, 78, 769, 661, 452, 983, 356, 217, 394, 342, 697, 878,
         *
         * 475, 250, 468, 33, 966, 742, 436, 343, 255, 944, 588, 734, 540, 508, 779, 881, 153, 928, 764, 703,
         *
         * 459, 840, 949, 500, 648, 163, 547, 780, 749, 132, 546, 199, 701, 448, 265, 263, 87, 45, 828, 634.
         *
         * 小蓝想从中选出一部分数求和，使得和是 24 的倍数，请问这个和最大是多少？
         */

    }

    private static int cost = 0;
    private static int num = 1;
    private static int cost1(int num){
        cost++;
        num++;
        return num;
    }
    private static int cost3(int num){
        cost += 3;
        int tempNum = num;
        int max = 0;
        while(tempNum != 0){
            if((tempNum % 10)>max){
                max = tempNum % 10;
            }
            tempNum /= 10;
        }
        num += max;
        return num;
    }
    private static int cost10(int num){
        cost += 10;
        num *= 2;
        return num;
    }
    public static void main4(String[] args) {
        /**
         * 小蓝有一个整数，初始值为 1 ，他可以花费一些代价对这个整数进行变换。
         *
         * 数字x，代价y
         * 小蓝可以花费 1 的代价将整数增加 1 。
         *          x+1 = cost3(x)
         *          y+1 < y + 3;
         * 小蓝可以花费 3 的代价将整数增加一个值，这个值是整数的数位中最大的那个（1 到 9）。
         *   x+1 < cost3(x)
         *   cost3(x) = cost10(x)
         *   y+3 < y+10
         *
         * 小蓝可以花费 10 的代价将整数变为原来的 2 倍。
         *  cost3(x) < cost10(x)
         *
         * 例如，如果整数为 16，花费 3 将整数变为 22 。
         *
         * 又如，如果整数为 22，花费 1 将整数变为 23 。
         *
         * 又如，如果整数为 23，花费 10 将整数变为 46 。
         *
         * 请问，如果要将整数从初始值 1 变为 2024，请问最少需要多少代价？
         */
//        System.out.println(cost1(22));
//        System.out.println(cost3(16));
//        System.out.println(cost10(23));
        for(int i = num; i <= 2024; ){
            int j = i;
            int cost1 = 0, cost3 = 0, cost10 = 0;
            int num1 = cost1(i);
            cost1 = cost;
            cost = 0;
            i = j;
            int num2 = cost3(i);
            cost3 = cost;
            cost = 0;
            i = j;
            int num3 = cost10(i);
            cost10 = cost;
            cost = 0;
            i = j;
            if(num1 == num2 && num2 == num3){
                cost1(i);
            }else if(num2 == num3){
                cost3(i);
            }
        }


    }
    public static void main3(String[] args) {
        /**
         * 两个数按位异或是指将这两个数转换成二进制后，最低位与最低位异或作为结果的最低位，次低位与次低位异或作为结果的次低位，以此类推。
         *
         * 例如，3 与 5 按位异或值为 6 。
         *
         * 请问，有多少个不超过 2024 的正整数，与 2024 异或后结果小于 2024 。
         */
        //System.out.println(3^5);
        int count = 0;
        for(int i = 1; i <= 2024; i++){
            if((i ^ 2024) < 2024){
                count++;
            }
        }
        System.out.println("count = " + count);
    }
    public static void main2(String[] args) {
        /**
         * 对于两个整数 a, b，既是 a 的整数倍又是 b 的整数倍的数称为 a 和 b 的公倍数。公倍数中最小的正整数称为 a 和 b 的最小公倍数。
         *
         * 请问， 2024 和 1024 的最小公倍数是多少？
         */
        for(int i = 2024; ;i++){
            if(i % 2024 == 0 &&
            i % 1024 == 0){
                System.out.println(i);
                break;
            }
        }
    }
    public static void main1(String[] args) {
        /**
         * 如果一个数 p 是个质数，同时又是整数 a 的约数，则 p 称为 a 的一个质因数。
         *
         * 请问， 2024 的最大的质因数是多少？
         */
        List<Integer> ZhiSu = new ArrayList<>();
        for(int i = 2; i <= 2024; i++){
            int j = 2;
            for(; j < i; j++){
                if(i % j == 0){
                    break;
                }
            }
            if(i == j){
                ZhiSu.add(i);
                System.out.println(i);
            }
        }
        int num = ZhiSu.size();
        for(int i = num - 1; i > 0; i--){
            if(2024 % i == 0){
                System.out.println(i);
                break;
            }
        }
    }
}
